home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / MM2_DEV / S / GEM / WINDOWBA.D < prev    next >
Encoding:
Modula Definition  |  1990-10-09  |  24.9 KB  |  574 lines
  1. DEFINITION MODULE WindowBase;
  2.  
  3.  
  4. (*  System              : Megamax Modula-2
  5.  *  Autor & Copyright   : Manuel Chakravarty
  6.  *  Vertrieb            : Application Systems Heidelberg
  7.  *  Version             : V1.1
  8.  *)
  9.  
  10. (*  Dies ist das grundlegende Modul für die Fensterverwaltung. Alle anderen
  11.  *  Fenstermodule bauen auf ihm auf. Der Fensterinhalt ist völlig unbestimmt
  12.  *  und wird vom Klientenmodul durch Prozedurvariablen (sogenannte server)
  13.  *  festgelegt.
  14.  *  Die aktuelle Implemetierung des Moduls setzt auf den AES-Fenstern des
  15.  *  GEM auf. Trotzdem ist es für den Benutzer dieses Moduls nicht nötig, daß
  16.  *  er sich mit den Details der AES-Fensterprogrammierung auskennt. Wird re-
  17.  *  gelmäßig die Prozedur 'EventHandler.HandleEvents' aufgerufen, so ist es
  18.  *  nicht nötig weitere AES-Routinen zu verwenden. Lediglich zum Darstellen
  19.  *  der Fensterinhalte werden das VDI oder eigenen Grafikroutinen benötigt.
  20.  *
  21.  *  Einige Bezeichnungen und ihre Verwendung in diesem Modul
  22.  *  --------------------------------------------------------
  23.  *
  24.  *  -- "aktives Fenster": Dies ist das oberste Fenster. Seine Fensterelemente
  25.  *     sind eingezeichnet und manipulierbar.
  26.  *  -- "Arbeitsbereich": Dies ist der Teil eines Fensters, der den sichtbaren
  27.  *     Teil des Fensterinhaltes enthält.
  28.  *  -- "Anwender": Der Anwender ist der Mensch, der vor dem Computer sitzt
  29.  *     und gerade mit einem fertigen Programm arbeitet, ohne unbedingt etwas
  30.  *     mit seiner Programmierung zu tun zu haben.
  31.  *  -- "Anwendung": Dies ist ein fertiges Dienstprogramm, das von einem An-
  32.  *     wender angewendet wird.
  33.  *  -- "Benutzer": Der Benutzer eines Moduls A ist ein Programmierer, der
  34.  *     A in einem seiner Programme benutzt (importiert).
  35.  *  -- "Bildschirmkoordinaten": Dies ist das normale Koordinatensystem, das
  36.  *     seinen Ursprung in der linken, oberen Bildschirmecke hat und das vom
  37.  *     VDI verwendet wird, falls man den 'GEMEnv.InitGem' Aufruf mit der
  38.  *     Konstanten 'GEMEnv.RC' durchführt. Es wird in der Regel von Variablen
  39.  *     des Typs 'Point' oder 'Rectangle' verwendet.
  40.  *  -- "Fensterinhalt": Dies ist die Information, die innerhalb des Fensters
  41.  *     dargestellt wird. Es ist allerdings nicht nur der sichtbare Teil ge-
  42.  *     meint, sondern auch der Teil, der erst durch bewegen der Fensterslider
  43.  *     eingesehen werden kann.
  44.  *  -- "Fensterkoordinaten": Dieses Koordinatensystem hat seinen Ursprung in
  45.  *     der linken, oberen Ecke des Fensterinhaltes und verändert sich mit
  46.  *     jeder Bewegung des Fensters oder dessen Slider. Dieses Koordinaten-
  47.  *     sytem wird in der Regel von Variablen des Typs 'LongPnt' oder 'LongRect'
  48.  *     verwendet.
  49.  *  -- "Klient": Als Klient oder Klientenmodul eines Moduls A wird ein Modul
  50.  *     bezeichnet, falls es A importiert.
  51.  *  -- "Neuzeichnen": Darunter versteht man, daß ein Teilbereich eines Fen-
  52.  *     sters neu gezeichnet wird, z.B. weil ein darüberliegendes Fenster
  53.  *     entfernt wurde oder der Fensterinhalt geändert worden ist.
  54.  *  -- "Slider": Auch Scroll-Balken oder Fensterschieber genannt bezeichnen
  55.  *     die Fensterelemente, die anzeigen welcher Teil des Fensterinhaltes
  56.  *     gerade sichtbar ist und es erlauben durch Verschieben mit der Maus
  57.  *     andere Teile sichtbar zu machen.
  58.  *  -- "virtuelle Koordinaten": Entspricht Fensterkoordinaten.
  59.  *
  60.  *  Einige Bemerkungen zu den Koordinatensystemen und dem Typ 'WindowSpec'
  61.  *  ----------------------------------------------------------------------
  62.  *
  63.  *  Es werden zwei Koordinatensysteme verwendet und zwar Bildschimkoordi-
  64.  *  naten und Fensterkoordinaten. Das erste System wird zur Kommunikation
  65.  *  mit dem VDI gebraucht, daher dient es vor allem zum Angeben von Rechteck-
  66.  *  bereichen, die neugezeichnet oder verschoben werden sollen. Das Zweite
  67.  *  ist für Berechnungen, die den gesamten Fensterinhalt betreffen gedacht
  68.  *  und hat daher auch den größeren Wertebereich. Zur Umrechnung zwischen
  69.  *  beiden System wird die Fensterbeschreibung 'spec' vom Typ 'WindowSpec'
  70.  *  gebraucht und es gilt:
  71.  *
  72.  *          (x, y) = (spec.virtual.x + xw, spec.virtual.y + yw),
  73.  *
  74.  *  wobei (x, y) ein Punkt in Bildschirmkoordinaten und (xw, yw) derselbe
  75.  *  Punkt in Fensterkoordinaten ist.
  76.  *  Die beiden Felder von 'WindowSpec' haben folgenden Inhalt:
  77.  *    'virtual' -- Lage und Größe des Fensterinhaltes in Bezug zum Bildschirm-
  78.  *                 koorinatensystem
  79.  *    'visible' -- Lage und Größe des sichtbaren Fensterinhalts (Arbeitsbe-
  80.  *                 reichs) in Bezug zu 'virtual'
  81.  *
  82.  *  Daraus ergeben sich folgende Tatsachen für den Zustand des Fensters:
  83.  *    i)   Der Arbeitsbereich ist 'LRect (virtual.x + visible.x,
  84.  *                                        virtual.y + visible.y,
  85.  *                                        visible.w, visible.h)'
  86.  *    ii)  Die horizontale Sliderposition ist 'visible.x' und die vertikale
  87.  *         'visible.y', außerdem ist die Größe der Slider 'visible.w' bzw.
  88.  *         'visible.h'
  89.  *    iii) Die Breite bzw. Höhe des Fensterinhaltes ist 'virtual.w' bzw.
  90.  *         'virtual.h'
  91.  *    iv)  Soll das Fenster verschoben werden, so muß 'virtual.x/y' um diesen
  92.  *         Betrag verschoben werden
  93.  *    v)   Soll das Fenster in der Größe verändert werden, so muß 'visible.w/h'
  94.  *         auf diese Breite bzw. Höhe gesetzt werden
  95.  *    vi)  Soll die Sliderposition verändert werden, so muß 'visible.x/y' auf
  96.  *         den entsprechenden Wert gesetzt werden und 'virtual.x/y' um den
  97.  *         entgegengesetzten Betrag verschoben werden
  98.  *    vii) Soll die Slidergröße geändert werden, so muß 'virtual.w/h' in das
  99.  *         richtige Verhältnis zu 'visible.w/h' gesetzt werden.
  100.  *)
  101.  
  102.  
  103. FROM SYSTEM     IMPORT ADDRESS;
  104.  
  105. FROM GrafBase   IMPORT Point, Rectangle, LongPnt, LongRect;
  106.  
  107.  
  108. TYPE    Window;
  109.  
  110.  
  111.         (*  Mögliche Fensterelemente. Es bedeutet:
  112.          *
  113.          *    'closeElem'  -- Das Fenster besitzt ein Schließfeld, daß vom
  114.          *                    Anwender betätigt werden kann.
  115.          *    'sizeElem'   -- Das Fenster kann vom Anwender in der Größe
  116.          *                    verändert werden.
  117.          *    'moveElem'   -- Die Lage des Fensters kann vom Anwender ver-
  118.          *                    ändert werden.
  119.          *    'scrollElem' -- Der Anwender kann bestimmen, welchen Teil des
  120.          *                    Fensterinhaltes er sehen möchte.
  121.          *    'titleElem'  -- Das Fenster besitzt einen Titel.
  122.          *    'infoElem'   -- Das Fenster besitzt eine Informationszeile.
  123.          *)
  124.         WdwElement      = (closeElem, sizeElem, moveElem, scrollElem,
  125.                            titleElem, infoElem);
  126.         WdwElemSet      = SET OF WdwElement;
  127.         
  128.         
  129.         (*  Mögliche Fensterzustände. Es bedeutet:
  130.          *
  131.          *    'hiddenWdw' -- Das Fenster ist für den Anwender nicht sichtbar.
  132.          *    'topWdw'    -- Das Fenster ist das oberste aller sichtbaren
  133.          *                   Fenster und kann somit vom Anwender beeinflußt
  134.          *                   werden.
  135.          *)
  136.         WdwFlag         = (hiddenWdw, topWdw);
  137.         WdwFlagSet      = SET OF WdwFlag;
  138.         
  139.         (*  Scroll-Modi
  140.          *)
  141.         WindowScrollMode= (columnLeftWdw, columnRightWdw, rowUpWdw, rowDownWdw,
  142.                            pageLeftWdw, pageRightWdw, pageUpWdw, pageDownWdw);
  143.         
  144.         
  145.         (*  Zustandsbeschreibung des Fensters
  146.          *)
  147.          
  148.         WindowSpec      = RECORD
  149.                             
  150.                             (*  Lage des gesamten Fensterinhaltes innerhalb
  151.                              *  des Weltkoordinatensystems.
  152.                              *)
  153.                             virtual     : LongRect;
  154.                             
  155.                             (*  Lage des sichtbaren Fensterinhaltes relativ
  156.                              *  zum gesamten Fensterinhalt. Dabei ist es er-
  157.                              *  laubt, daß 'visible' 'virtual' überschreit-
  158.                              *  tet.
  159.                              *)
  160.                             visible     : LongRect;
  161.                             
  162.                           END;
  163.         
  164.         (*  Fenster-Server  *)
  165.         
  166.         (*  Soll den angegebenen Bildschirmausschnitt bei einem Aufruf
  167.          *  kopieren bzw. neuzeichnen. Die Vereinigung von 'source' und
  168.          *  'dest' ist immer gleich der Vereinigung von 'dest' und 'new'.
  169.          *  Ist 'source.w = 0', so muß nicht kopiert werden.
  170.          *  Der Anwendung ist es freigestellt, ob Sie den zu kopierenden
  171.          *  Bereich wirklich kopiert oder das Zielgebiet 'dest' einfach
  172.          *  neuzeichnet.
  173.          *)
  174.         UpdateWdwProc   = PROCEDURE ((* wdw   : *) Window,
  175.                                      (* env   : *) ADDRESS,
  176.                                      (* source: *) Rectangle,
  177.                                      (* dest  : *) Rectangle,
  178.                                      (* new   : *) Rectangle);
  179.         
  180.         (*  Soll den angegebene Fensterzustand überprüfen und gegeben-
  181.          *  falls korrigieren. Dabei muß darauf geachtet werden, daß
  182.          *  der Arbeitsbereich des Fensters vollständig in 'border' liegt.
  183.          *)
  184.         CheckSpecWdwProc= PROCEDURE (    (* wdw   : *) Window,
  185.                                          (* env   : *) ADDRESS,
  186.                                      VAR (* spec  : *) WindowSpec,
  187.                                          (* border: *) LongRect);
  188.  
  189.         (*  Soll die Anzahl der Pixel liefern, um die gescrollt werden soll.
  190.          *)
  191.         ScrollAmtWdwProc= PROCEDURE ((* wdw : *) Window,
  192.                                      (* env : *) ADDRESS,
  193.                                      (* mode: *) WindowScrollMode): LONGINT;
  194.                                         
  195.         (*  Teile der Anwendung mit, daß das angegebene Fenster zum ober-
  196.          *  sten Fenster gemacht wurde.
  197.          *
  198.          *  ACHTUNG: Diese Prozedur wird in der aktuellen Implementation
  199.          *           nie genutzt.
  200.          *)
  201.         ActivatedWdwProc= PROCEDURE ((* wdw: *) Window,
  202.                                      (* env: *) ADDRESS);
  203.                                        
  204.         
  205.         (*  Teile der Anwendung mit, daß der Anwender das Schließfeld des
  206.          *  Fensters selektiert hat.
  207.          *)
  208.         CloseWdwProc    = PROCEDURE ((* wdw: *) Window,
  209.                                      (* env: *) ADDRESS);
  210.         
  211.         
  212. CONST   NoWindow        = Window (NIL); (*  Unbesetzte Fensterkennung  *)
  213.  
  214.  
  215.                         (*  Fensterverwaltung  *)
  216.                         (*  =================  *)
  217.         
  218. PROCEDURE CreateWindow (VAR wdw            : Window;
  219.  
  220.                             elems          : WdwElemSet;
  221.                             updateServer   : UpdateWdwProc;
  222.                             checkSpecServer: CheckSpecWdwProc;
  223.                             scrollAmtServer: ScrollAmtWdwProc;
  224.                             activatedServer: ActivatedWdwProc;
  225.                             closeServer    : CloseWdwProc;
  226.                             serverEnv      : ADDRESS);
  227.                         
  228.         (*  Erzeugt und initalisiert ein neues Fenster.
  229.          *
  230.          *  Dabei gibt 'elems' an welche Fensterelemente das neue Fenster
  231.          *  besitzen soll und die '...Server'-Parameter bestimmen durch
  232.          *  ihre Funktion (Semantik) das Verhalten und den Inhalt des Fen-
  233.          *  sters. 'serverEnv' ist ein Zeiger auf eine vom Klientenmodul
  234.          *  frei bestimmbare Datenstruktur. Dieser Zeiger wird jedem Server
  235.          *  beim Aufruf übergeben (in 'env') und kann zum Beispiel auf ein
  236.          *  Record zeigen, das alle Informationen über Inhalt und Aussehen
  237.          *  des Fensters beinhaltet.
  238.          *
  239.          *  Ist 'WindowState (wdw) = invalidWdw', so konnte das Fenster aus
  240.          *  Mangel an Speicherplatz nicht erzeugt werden.
  241.          *)
  242.  
  243. PROCEDURE SysCreateWindow (VAR wdw            : Window;
  244.  
  245.                                elems          : WdwElemSet;
  246.                                updateServer   : UpdateWdwProc;
  247.                                checkSpecServer: CheckSpecWdwProc;
  248.                                scrollAmtServer: ScrollAmtWdwProc;
  249.                                activatedServer: ActivatedWdwProc;
  250.                                closeServer    : CloseWdwProc;
  251.                                serverEnv      : ADDRESS);
  252.  
  253.         (*  Erzeugt ein neues Fenster, das erst abgemeldet wird, sobald
  254.          *  'WindowBase' aus dem Speicher entfernt wird.
  255.          *)
  256.                         
  257. PROCEDURE DeleteWindow (VAR wdw: Window);
  258.  
  259.         (*  Meldet ein Fenster ab, dabei wird es falls nötig zuvor geschlos-
  260.          *  sen.
  261.          *
  262.          *  Nach diesem Aufruf ist 'wdw' keine gültige Kennung mehr.
  263.          *  Wird ein Fenster nicht vom Klientenmodul durch Aufruf dieser
  264.          *  Prozedur abgemeldet, so erledigt dies 'WindowBase' selbst, bei
  265.          *  der Beendigung (Terminierung) des Klienten. Eine Ausnahme bilden
  266.          *  mit 'SysCreateWindow' erzeugt Fenster.
  267.          *)
  268.  
  269.  
  270. PROCEDURE OpenWindow (wdw: Window);
  271.  
  272.         (*  Öffnet ein Fenster, d.h. das Fenster wird auf dem Bildschirm
  273.          *  dargestellt.
  274.          *)
  275.          
  276. PROCEDURE CloseWindow (wdw: Window);
  277.  
  278.         (*  Schließt ein Fenster, d.h. entfernt es vom Bildschirm.
  279.          *
  280.          *  Dabei wird das Fenster nicht gelöscht (siehe 'DeleteWindow'),
  281.          *  auch seine Ausmaße, Lage und momentane Sliderstellung bleiben
  282.          *  erhalten und werden bei einem erneuten 'OpenWindow' wiederver-
  283.          *  wendet.
  284.          *)
  285.  
  286. TYPE    WindowCopyMode = (noCopyWdw, copyHorWdw, copyVertWdw);
  287.         
  288. PROCEDURE UpdateWindow (wdw   : Window;
  289.                         update: UpdateWdwProc;
  290.                         env   : ADDRESS;
  291.                         frame : LongRect;
  292.                         mode  : WindowCopyMode;
  293.                         amount: LONGINT);
  294.  
  295.         (*  Erzwingt das Neuzeichnen eines Teils des Fensterinhaltes.
  296.          *
  297.          *  Eingabeparameter:
  298.          *  -----------------
  299.          *
  300.          *    'wdw'    -- Kennzeichnet das angesprochene Fenster.
  301.          *    'update' -- Bestimmt die zu verwendende Zeichenroutine. Meist
  302.          *                ist es die gleiche, die bei 'CreateWindow' als
  303.          *                'updateServer' angegeben wurde.
  304.          *    'env'    -- Zeiger auf eine vom Klientenmodul zu bestimmende
  305.          *                Datenstruktur, der an 'update' weitergegeben wird.
  306.          *    'frame'  -- Bestimmt den Fensterausschnitt, der neu gezeichnet
  307.          *                werden soll. Die Angabe erfolgt in Fensterkoordi-
  308.          *                naten.
  309.          *    'mode'   -- Bestimmt ob und wenn ja in welche Richtung der an-
  310.          *                gegebene Fensterausschnitt verschoben werden soll.
  311.          *
  312.          *                  'noCopyWdw'   -- Keine Verschiebung
  313.          *                  'copyHorWdw'  -- Horizontale Verschiebung
  314.          *                  'copyVertWdw' -- Vertikale Verschiebung
  315.          *
  316.          *    'amount' -- Bestimmt um welchen Betrag der Auschnitt verschoben
  317.          *                werden soll. Dabei verschieben positive Werte nach
  318.          *                rechts bzw. unten und negative nach links bzw. oben.
  319.          *)
  320.  
  321. PROCEDURE RedrawWindow (wdw: Window);
  322.  
  323.         (*  Erzwingt das Neuzeichnen des gesamten sichtbaren Fensterinhaltes.
  324.          *)
  325.  
  326.  
  327.                         (*  Setzfunktionen  *)
  328.                         (*  ==============  *)
  329.  
  330. PROCEDURE SetWindowSpec (wdw: Window; spec: WindowSpec);
  331.  
  332.         (*  Setzt eine neuen Fensterbeschreibung.
  333.          *
  334.          *  Die Fensterbeschreibung wird in die interne Verwaltungsdaten-
  335.          *  struktur übernommen und falls das Fenster sichtbar ist, werden
  336.          *  Fenstergröße, -position und -sliderstellung sofern sie sich ge-
  337.          *  ändert haben an das AES weitergegeben.
  338.          *
  339.          *  Hinweis: Sollte sich die Sliderstellung geändert haben, so wird
  340.          *           nicht unbedingt ein Neuzeichnen o.ä. ausgelößt. Soll mit
  341.          *           dem Ändern der Sliderstellung gleichzeeitig der Fenster-
  342.          *           inhalt verschoben werden, so sollte 'SetWindowSliderPos'
  343.          *           verwendet werden.
  344.          *)
  345.  
  346.  
  347. TYPE    SetWdwStrMode   = (titleWdwStr, infoWdwStr);
  348.  
  349. PROCEDURE SetWindowString (    wdw : Window;
  350.                                mode: SetWdwStrMode;
  351.                            REF str : ARRAY OF CHAR);
  352.  
  353.         (*  Setzt den Titel oder die Informationszeile eines Fensters.
  354.          *
  355.          *  Die angegebene Zeichenkette wird übernommen und falls das Fenster
  356.          *  sichtbar ist sofort dargestellt.
  357.          *
  358.          *  Ist das angesprochene Fensterelement nicht vorhanden, so liefert
  359.          *  'WindowState (wdw)' den Wert 'invalidElemWdw'.
  360.          *)
  361.  
  362. CONST   CenterWdw = MinInt;       (*  Hor./vert. zentriert          *)
  363.         MaxWdw    = MinInt;       (*  Maximale Fensterbreite/-höhe  *)
  364.         
  365. PROCEDURE SetWindowWorkArea (wdw     : Window;
  366.                              workArea: Rectangle);
  367.         
  368.         (*  Setzt den Arbeitsbereich eines Fensters in Bildschirmkoordinaten.
  369.          *
  370.          *  Sobald nötig wird durch diese Routine ein Neuzeichnen von Teilen
  371.          *  des Fensterinhaltes ausgelößt.
  372.          *
  373.          *  Es können die Sonderwerte 'CenterWdw' und 'MaxWdw' übergeben wer-
  374.          *  den. Ersterer bewirkt bei x- und y-Werten das Zentrieren des Fen-
  375.          *  sters innerhalb des Desktops. 'MaxWdw' sorgt bei w- und h-Werten
  376.          *  dafür, daß das Fenster auf maximale Breite bzw. Höhe gesetzt
  377.          *  wird.
  378.          *)
  379.  
  380.  
  381. CONST   OldWindowSlider = MinLInt;
  382.  
  383. PROCEDURE SetWindowSliderPos (wdw: Window; horPos, vertPos: LONGINT);
  384.  
  385.         (*  Setzt die Fensterslider, also den sichtbaren Bereich des Fenster-
  386.          *  inhaltes.
  387.          *
  388.          *  Die neuen Werte werden übernommen und außerdem werden nicht nur
  389.          *  die Slider auf die neuen Werte gesetzt, sondern auch der Fenster-
  390.          *  inhalt durch einen Aufruf von 'updateServer' auf den neusten
  391.          *  Stand gebracht.
  392.          *
  393.          *  Soll der horizontale oder vertikale Slider unverändert bleiben,
  394.          *  so kann der Werte 'OldWindowSlider' übergeben werden.
  395.          *)
  396.  
  397. PROCEDURE PutWindowOnTop (wdw: Window);
  398.  
  399.         (*  Macht das Fenster zum obersten und somit aktiven Fenster.
  400.          *)
  401.  
  402. PROCEDURE ResetWindowState (wdw: Window);
  403.  
  404.         (*  Setzt einen eventuellem Fehlerzustand zurück.
  405.          *
  406.          *  Wird durch eine der Routinen ein Fehler erkannt und dieser nicht
  407.          *  zurückgesetzt, so wird beim nächsten Aufruf einer Routinen mit
  408.          *  demselben Fenster ein Laufzeitfehler ausgelößt.
  409.          *)
  410.  
  411.  
  412.                         (*  Nachfragefunktionen  *)
  413.                         (*  ===================  *)
  414.  
  415. PROCEDURE GetWindowSpec (wdw: Window; VAR spec: WindowSpec);
  416.  
  417.         (*  Ermittelt die aktuelle Fensterbeschreibung.
  418.          *)
  419.  
  420. PROCEDURE WindowWorkArea (wdw: Window): Rectangle;
  421.  
  422.         (*  Liefert die aktuellen Ausmaße des Arbeitsbereichs des bezeich-
  423.          *  neten Fensters in Bildschirmkoordinaten.
  424.          *)
  425.  
  426. PROCEDURE GetWindowSliderPos (wdw: Window; VAR horPos, vertPos: LONGINT);
  427.  
  428.         (*  Ermittelt die aktuelle Lage des sichtbaren Bereichs innerhalb
  429.          *  des gesamten Fensterinhaltes.
  430.          *
  431.          *  Entspricht den Werten 'spec.visible.x' und 'spec.visible.y', die
  432.          *  von der Prozedur 'GetWindowSpec' geliefert werden.
  433.          *)
  434.  
  435. PROCEDURE WindowFlags (wdw: Window): WdwFlagSet;
  436.  
  437.         (*  Liefert den aktuellen Fensterzustand.
  438.          *)
  439.  
  440.  
  441. TYPE    WdwState        = (okWdw, cantOpenWdw, alreadyOpenWdw, alreadyCloseWdw,
  442.                            invalidElemWdw, invalidWdw);
  443.  
  444. PROCEDURE WindowState (wdw: Window): WdwState;
  445.  
  446.         (*  Liefert den aktuellen Fehlerzustand des Fensters.
  447.          *
  448.          *  Die Fehlermeldung bezieht sich immer auf die letzte mit dieser
  449.          *  Fensterkennung durchgeführt Operation, mit Ausnahme des letzten
  450.          *  Fehlers 'invalidWdw', der sich direkt auf die übergebene Kennung
  451.          *  bezieht.
  452.          *
  453.          *  HINWEIS: Wurde ein Fehler erkannt und soll dieser nicht zu einem
  454.          *           Laufzeitfehler führen, so muß 'ResetWindowState' aufge-
  455.          *           rufen werden.
  456.          *)
  457.  
  458. PROCEDURE MinWindowWorkArea (wdw: Window): Rectangle;
  459.  
  460.         (*  Liefert die minimale Höhe und Breite eines Fensters. Sowie die
  461.          *  linkeste und oberste Position.
  462.          *
  463.          *  ACHTUNG: Darf vom 'checkStateServer' nicht aufgerufen werden!
  464.          *)
  465.  
  466. PROCEDURE MaxWindowWorkArea (wdw: Window): Rectangle;
  467.  
  468.         (*  Liefert die maximale Höhe und Breite, sowie die linkeste und
  469.          *  oberste Position eines Fensters.
  470.          *
  471.          *  ACHTUNG: Darf vom 'checkStateServer' nicht aufgerufen werden!
  472.          *)
  473.  
  474.  
  475. TYPE    DetectWdwResult = (noWdwDWR, unkownWdwDWR, foundWdwDWR);
  476.  
  477. PROCEDURE DetectWindow (REF targets: ARRAY OF Window;
  478.                             noTrgs : CARDINAL;
  479.                             loc    : Point;
  480.                         VAR wdw    : Window;
  481.                         VAR result : DetectWdwResult);
  482.  
  483.         (*  Ermittelt das an einer bestimmten Bildschirmposition befindliche
  484.          *  Fenster.
  485.          *
  486.          *  Eingabeparameter:
  487.          *  -----------------
  488.          *
  489.          *    'targets' -- Liste aller Fenster nach denen gesucht werden soll.
  490.          *    'noTrgs'  -- Gibt an wieviele Einträge in 'targets' relevant
  491.          *                 sind, wird der Werte '0' übergeben, so werden alle
  492.          *                 Einträge benutzt.
  493.          *    'loc'     -- Die zu untersuchende Bildschirmposition.
  494.          *
  495.          *  Ausgabeparameter:
  496.          *  -----------------
  497.          *
  498.          *    'wdw'     -- Falls an der Position 'loc' ein in 'targets' ange-
  499.          *                 gebenes Fenster liegt, so wird dessen Kennung ge-
  500.          *                 liefert, sonst wird 'NoWindow' geliefert.
  501.          *    'result'  -- Falls an der angegebenen Stelle kein Fenster liegt,
  502.          *                 so wird 'noWdwDWR' geliefert. Ist das unter 'loc'
  503.          *                 liegende Fenster in 'targets' eingetragen, so wird
  504.          *                 'foundWdwDWR', sonst 'unkownWdwDWR' geliefert.
  505.          *
  506.          *  HINWEIS: In 'targets' sind auch Einträge mit dem Wert 'NoWindow'
  507.          *           erlaubt.
  508.          *)
  509.  
  510. PROCEDURE FullArea (): Rectangle;
  511.  
  512.         (*  Liefert die Ausmaße der Desktopoberfläche, die mit Fenster be-
  513.          *  legt werden kann.
  514.          *)
  515.          
  516.          
  517.                 (*  Rechenfunktionen  *)
  518.                 (*  ================  *)
  519.  
  520. PROCEDURE CalcWindowCoor (    wdw      : Window;
  521.                               screenLoc: Point;
  522.                           VAR wdwLoc   : LongPnt;
  523.                           VAR legal    : BOOLEAN);
  524.  
  525.         (*  Wandelt eine Punkt von Bildschirm- in -Fensterkoordinaten um.
  526.          *
  527.          *  Eingabeparameter:
  528.          *  -----------------
  529.          *
  530.          *    'wdw'       -- Kennung des Fensters, dessen Koordinatensystem
  531.          *                   gemeint ist.
  532.          *    'screenLoc' -- Der Punkt in Bildschirmkoordinaten.
  533.          *
  534.          *  Ausgabeparameter:
  535.          *  -----------------
  536.          *
  537.          *    'wdwLoc'    -- Der Punkt in Fensterkoordinaten.
  538.          *    'legal'     -- Liefert 'TRUE', falls der Punkt innerhalb des
  539.          *                   Fensterinhaltes ('spec.virtual') liegt. Die
  540.          *                   Umwandlung ist aber auf jeden Fall korrekt.
  541.          *)
  542.  
  543. PROCEDURE CalcScreenCoor (    wdw      : Window;
  544.                               wdwLoc   : LongPnt;
  545.                           VAR screenLoc: Point;
  546.                           VAR success  : BOOLEAN);
  547.         
  548.         (*  Wandelt einen Punkt von Fenster- in Bildschirmkoordinaten um.
  549.          *
  550.          *  Eingabeparameter:
  551.          *  -----------------
  552.          *
  553.          *    'wdw'       -- Kennung des Fensters, dessen Koordinatensystem
  554.          *                   gemeint ist.
  555.          *    'wdwLoc'    -- Der Punkt in Fensterkoordinaten.
  556.          *
  557.          *  Ausgabeparameter:
  558.          *  -----------------
  559.          *
  560.          *    'screenLoc' -- Der Punkt in Bildschirmkoordinaten.
  561.          *    'success'   -- Liefert 'TRUE', falls der Punkt im Wertebereich
  562.          *                   des Typs 'Point' liegt. Ist dies nicht der Fall,
  563.          *                   so wird der am nächsten liegende Punkt innerhalb
  564.          *                   des Wertebereichs geliefert.
  565.          *)
  566.  
  567. PROCEDURE BorderToWorkArea (wdw: Window; borderArea: Rectangle): Rectangle;
  568.  
  569.         (*  Berechnet zu gegebenen Randausmaßen den Arbeitsbereich eines
  570.          *  Fensters.
  571.          *)
  572.  
  573.  
  574. END WindowBase.